package qc.module.duty.service;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import qc.common.core.unify.QCUnifyReturnValue;
import qc.module.duty.dto.group.DutyGroupDto;
import qc.module.duty.dto.staff.DutyStaffDto;
import qc.module.duty.dto.team.DutyTeamAddMembersDto;
import qc.module.duty.dto.team.DutyTeamDto;
import qc.module.duty.dto.team.DutyTeamMemberDto;
import qc.module.duty.entity.DutyGroup;
import qc.module.duty.entity.DutyTeam;
import qc.module.duty.mapper.DutyTeamMapper;
import qc.module.duty.repository.DutyTeamRepository;

import java.util.List;

/**
 * @projectName: qcdp
 * @package: qc.module.duty.service
 * @className: DutyTeamService
 * @date: 2023/8/9
 * @version: 1.0
 */

@Service
public class DutyTeamService {


    private DutyTeamRepository dutyTeamRepository;

    @Autowired
    public void setDutyTeamRepository(DutyTeamRepository dutyTeamRepository) {
        this.dutyTeamRepository = dutyTeamRepository;
    }

    private DutyTeamMemberService dutyTeamMemberService;

    @Autowired
    public void setDutyTeamMemberService(DutyTeamMemberService dutyTeamMemberService) {
        this.dutyTeamMemberService = dutyTeamMemberService;
    }

    private DutyGroupService dutyGroupService;

    @Autowired
    public void setDutyGroupService(DutyGroupService dutyGroupService) {
        this.dutyGroupService = dutyGroupService;
    }

    private DutyStaffService dutyStaffService;

    @Autowired
    public void setDutyStaffService(DutyStaffService dutyStaffService) {
        this.dutyStaffService = dutyStaffService;
    }

    /**
     * 获取所有值班班组信息或当前用户所在部门的值班班组信息，按值班分组排序号升序
     *
     * @return List<DutyTeamDto> 返回结果集
     * @author QcCheng Tech
     * @date 2023/8/9
     */
    public List<DutyTeamDto> query(List<Integer> userDeptIds, Boolean isQueryAll) {
        // 创建 MPJLambdaWrapper 对象来构建查询条件和关联表
        MPJLambdaWrapper<DutyTeam> wrapper = new MPJLambdaWrapper<>();
        wrapper.select(DutyTeam::getId, DutyTeam::getName);// 查询所有DutyTeam表的字段
        wrapper.selectAs(DutyGroup::getDept, DutyTeamDto::getDeptid);//查询部门id
        // 将DutyGroup的name字段映射为DutyTeamDto的groupname字段
        wrapper.selectAs(DutyGroup::getName, DutyTeamDto::getGroupname);
        wrapper.selectAs(DutyTeam::getGid, DutyTeamDto::getGroupid);

        if (!isQueryAll) {
            // 在DutyGroup的dept字段中查询包含在userDeptIds列表中的值
            wrapper.in(DutyGroup::getDept, userDeptIds);
        }

        // 内连接DutyGroup表，并通过DutyGroup的id和DutyTeam的gid字段进行关联
        wrapper.innerJoin(DutyGroup.class, DutyGroup::getId, DutyTeam::getGid);

        // 按照DutyGroup的odr字段升序排序
        wrapper.orderByAsc(DutyGroup::getOdr);

        // 使用 dutyTeamRepository 执行查询，并将结果映射为 DutyTeamDto 对象的列表
        List<DutyTeamDto> dutyTeamList = dutyTeamRepository.selectJoinList(DutyTeamDto.class, wrapper);

        for (DutyTeamDto dutyTeamDto : dutyTeamList) {
            List<DutyTeamMemberDto> teamMembers = getTeamMembers(dutyTeamDto.getId());
            dutyTeamDto.setMembers(teamMembers);
        }


        return dutyTeamList;
    }


    /**
     * 获取指定的值班班组信息
     *
     * @param id: 指定的值班班组id
     * @return DutyTeamDto 返回结果集
     * @author QcCheng Tech
     * @date 2023/8/9
     */
    public DutyTeamDto get(int id) {
        // 通过id从dutyTeamRepository中查询DutyTeam对象
        DutyTeam dutyTeam = dutyTeamRepository.selectById(id);
        DutyGroupDto dutyGroupDto = dutyGroupService.get(Integer.parseInt(dutyTeam.getGid()));
        if (dutyTeam != null) {
            // 获取团队成员信息
            List<DutyTeamMemberDto> teamMembers = getTeamMembers(dutyTeam.getId());

            // 转换DutyTeam对象为DutyTeamDto对象
            DutyTeamDto dutyTeamDto = DutyTeamMapper.MAPPER.toDto(dutyTeam);

            //设置部门ID
            dutyTeamDto.setDeptid(dutyGroupDto.getDeptid());

            // 设置团队成员信息
            dutyTeamDto.setMembers(teamMembers);

            // 返回值班团队DTO对象
            return dutyTeamDto;
        }
        return null;
    }


    /**
     * 添加值班组
     *
     * @param dto:对象
     * @return String 添加成功返回null,错误返回错误信息
     * @author QcCheng Tech
     * @date 2023/8/9
     */
    public String add(DutyTeamDto dto) {
        if (dto == null)
            return QCUnifyReturnValue.Warn("对象不能为空");
        if (StringUtils.isBlank(dto.getName()))
            return QCUnifyReturnValue.Warn("值班组名不能为空");
        if (dto.getGroupid() < 0x1)
            return QCUnifyReturnValue.Warn("所属班组id不能为空");
        //判断名称不能重复
        if (isNameHasExist(dto.getName(), 0x0))
            return QCUnifyReturnValue.Warn("值班分组名称已存在，名称不能相同");
        //判断所属班组是否存在
        if (!dutyGroupService.hasIdExist(dto.getGroupid())) {
            return QCUnifyReturnValue.Warn("所属班组不存在");
        }
        //DTO转换为Entity
        DutyTeam dutyTeam = DutyTeamMapper.MAPPER.toEntity(dto);


        //值班班组id
        dutyTeam.setId(genereateId());

        if (dutyTeamRepository.insert(dutyTeam) < 0x1)
            return QCUnifyReturnValue.Warn("保存失败");
        return QCUnifyReturnValue.Success();
    }


    /**
     * 删除值班班组
     *
     * @param id: 值班班组id
     * @return String 成功返回null
     * @author QcCheng Tech
     * @date 2023/8/9
     */
    public String delete(int id) {
        // 判断该班值是否有成员
        List<DutyTeamMemberDto> dutyTeamMemberDtos = dutyTeamMemberService.get(id);
        if (dutyTeamMemberDtos != null && !dutyTeamMemberDtos.isEmpty()) {
            for (DutyTeamMemberDto dutyTeamMemberDto : dutyTeamMemberDtos) {
                // 删除该班值人员
                dutyTeamMemberService.delete(dutyTeamMemberDto);
            }
        }

        // 删除班值
        dutyTeamRepository.deleteById(id);

        return QCUnifyReturnValue.Success();
    }

    /**
     * 修改值班组
     *
     * @param dto 值班组信息
     * @return 成功返回null
     * @author QuCheng Tech
     * @date 2023/8/9
     */
    public String update(DutyTeamDto dto) {
        if (dto == null)
            return QCUnifyReturnValue.Warn("对象不能为空");
        if (StringUtils.isBlank(dto.getName()))
            return QCUnifyReturnValue.Warn("值班分组名称不能为空");
        if (dto.getGroupid() < 0x1)
            return QCUnifyReturnValue.Warn("所属部门ID不能为空");
        //判断名称不能重复
        if (isNameHasExist(dto.getName(), dto.getId()))
            return QCUnifyReturnValue.Warn("值班分组名称已存在，名称不能相同");

        //判断所属班组是否存在
        if (!dutyGroupService.hasIdExist(dto.getGroupid())) {
            return QCUnifyReturnValue.Warn("所属班组不存在");
        }
        //DTO转换为Entity
        DutyTeam dutyTeam = DutyTeamMapper.MAPPER.toEntity(dto);
        dutyTeamRepository.updateById(dutyTeam);

        return QCUnifyReturnValue.Success();
    }


    /**
     * 获取指定班值的成员列表
     *
     * @param id: 值班表id
     * @return DutyTeamMemberDto 返回信息
     * @author QcCheng Tech
     * @date 2023/8/10
     */
    public List<DutyTeamMemberDto> getTeamMembers(int id) {
        // 通过值班班值ID获取该班值中的成员id集合
        List<DutyTeamMemberDto> dutyTeamMemberDtos = dutyTeamMemberService.get(id);

        for (DutyTeamMemberDto dutyTeamMemberDto : dutyTeamMemberDtos) {
            // 根据团队成员ID调用值班人员服务获取值班人员详细信息
            DutyStaffDto dutyStaffDto = dutyStaffService.get(dutyTeamMemberDto.getMemberid());

            // 添加值班人员详细信息到团队成员DTO对象
            dutyTeamMemberDto.setMember(dutyStaffDto);
        }
        // 返回团队成员DTO对象
        return dutyTeamMemberDtos;
    }


    /**
     * 添加班值成员信息
     *
     * @param dto:班值添加成员信息
     * @return String 成功返回null
     * @author QcCheng Tech
     * @date 2023/8/10
     */
    public String addTeamMembers(DutyTeamAddMembersDto dto) {
        // 检查对象是否为空
        if (dto == null) {
            return QCUnifyReturnValue.Warn("对象不能为空");
        }
        if (dto.getId() < 0x1) {
            return QCUnifyReturnValue.Warn("班值ID不能为空");
        }
        if (dto.getMemberids() == null && dto.getMemberids().size() < 0x1) {
            return QCUnifyReturnValue.Warn("人员ID部门为空");
        }
        for (Integer memberId : dto.getMemberids()) {
            DutyTeamMemberDto teamMemberDto = new DutyTeamMemberDto();
            teamMemberDto.setId(dto.getId());
            teamMemberDto.setMemberid(memberId);
            setTeamMember(teamMemberDto);
        }
        return QCUnifyReturnValue.Success();
    }


    /**
     * 设置班值成员信息，后台判断存在时进行更新，不存在时进行新增；
     *
     * @param dutyTeamDto:设置信息
     * @return String 成功返回null
     * @author QcCheng Tech
     * @date 2023/8/10
     */
    public String setTeamMember(DutyTeamMemberDto dutyTeamDto) {
        // 检查对象是否为空
        if (dutyTeamDto == null) {
            return QCUnifyReturnValue.Warn("对象不能为空");
        }
        // 检查班值ID是否有效
        if (dutyTeamDto.getId() < 0x1) {
            return QCUnifyReturnValue.Warn("班值ID不能为空");
        }
        // 检查人员ID是否有效
        if (dutyTeamDto.getMemberid() < 0x1) {
            return QCUnifyReturnValue.Warn("人员ID不能为空");
        }

        // 判断是否存在该团队成员，若存在则更新，否则添加
        if (dutyTeamMemberService.isExist(dutyTeamDto.getId(), dutyTeamDto.getMemberid())) {
            dutyTeamMemberService.update(dutyTeamDto); // 更新信息
        } else {
            dutyTeamMemberService.add(dutyTeamDto); // 添加信息
        }

        return QCUnifyReturnValue.Success();
    }


    /**
     * 删除指定的班值成员
     *
     * @param dutyTeamDto:传入班值ID和成员ID；
     * @return String 成功返回null 失败返回错误信息
     * @author QcCheng Tech
     * @date 2023/8/11
     */
    public String deleteTeamMember(DutyTeamMemberDto dutyTeamDto) {
        if (dutyTeamDto == null) {
            return QCUnifyReturnValue.Warn("对象不能为空");
        }
        if (dutyTeamDto.getId() < 0x1) {
            return QCUnifyReturnValue.Warn("班值ID不能为空");
        }
        if (dutyTeamDto.getMemberid() < 0x1) {
            return QCUnifyReturnValue.Warn("人员ID不能为空");
        }
        // 进行删除操作,调用dutyScheduleMemberService的删除方法
        dutyTeamMemberService.delete(dutyTeamDto);
        return QCUnifyReturnValue.Success();
    }


    /**
     * 生成记录ID，获取数据库表中的最大记录ID+1
     *
     * @return 生成记录ID
     * @author QuCheng Tech
     * @since 2023/5/25
     */
    Integer genereateId() {
        Integer maxRecordId = getMaxId();
        return maxRecordId + 1;
    }


    /**
     * 获取数据库表中的最大ID值，没有记录时返回0
     *
     * @return 返回数据库表中的最大ID值
     * @author QuCheng Tech
     * @since 2023/5/25
     */
    Integer getMaxId() {
        LambdaQueryWrapper<DutyTeam> wrapper = new LambdaQueryWrapper<>();
        wrapper.select(DutyTeam::getId);
        wrapper.orderByDesc(DutyTeam::getId);
        DutyTeam en = dutyTeamRepository.selectOne(wrapper);
        if (en != null)
            return en.getId();

        return 0x0;
    }

    /**
     * @param name 名称
     * @param id   ID，新增时设置ID为0，修改时设置ID为记录ID
     * @return true表示名称已存在，false表示名称不存在
     * @author QuCheng Tech
     * @since 2023/5/25
     */
    boolean isNameHasExist(String name, Integer id) {
        //验证名称是否重复条件：name=name and id<>id
        LambdaQueryWrapper<DutyTeam> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(DutyTeam::getName, name);
        wrapper.ne(DutyTeam::getId, id);
        DutyTeam en = dutyTeamRepository.selectOne(wrapper);
        if (en != null)
            return true;

        return false;
    }


}
